home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / xml / dom / xmlbuilder.pyo (.txt) < prev   
Python Compiled Bytecode  |  2008-10-13  |  15KB  |  414 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import copy
  5. import xml.dom as xml
  6. from xml.dom.NodeFilter import NodeFilter
  7. __all__ = [
  8.     'DOMBuilder',
  9.     'DOMEntityResolver',
  10.     'DOMInputSource']
  11.  
  12. class Options:
  13.     namespaces = 1
  14.     namespace_declarations = True
  15.     validation = False
  16.     external_parameter_entities = True
  17.     external_general_entities = True
  18.     external_dtd_subset = True
  19.     validate_if_schema = False
  20.     validate = False
  21.     datatype_normalization = False
  22.     create_entity_ref_nodes = True
  23.     entities = True
  24.     whitespace_in_element_content = True
  25.     cdata_sections = True
  26.     comments = True
  27.     charset_overrides_xml_encoding = True
  28.     infoset = False
  29.     supported_mediatypes_only = False
  30.     errorHandler = None
  31.     filter = None
  32.  
  33.  
  34. class DOMBuilder:
  35.     entityResolver = None
  36.     errorHandler = None
  37.     filter = None
  38.     ACTION_REPLACE = 1
  39.     ACTION_APPEND_AS_CHILDREN = 2
  40.     ACTION_INSERT_AFTER = 3
  41.     ACTION_INSERT_BEFORE = 4
  42.     _legal_actions = (ACTION_REPLACE, ACTION_APPEND_AS_CHILDREN, ACTION_INSERT_AFTER, ACTION_INSERT_BEFORE)
  43.     
  44.     def __init__(self):
  45.         self._options = Options()
  46.  
  47.     
  48.     def _get_entityResolver(self):
  49.         return self.entityResolver
  50.  
  51.     
  52.     def _set_entityResolver(self, entityResolver):
  53.         self.entityResolver = entityResolver
  54.  
  55.     
  56.     def _get_errorHandler(self):
  57.         return self.errorHandler
  58.  
  59.     
  60.     def _set_errorHandler(self, errorHandler):
  61.         self.errorHandler = errorHandler
  62.  
  63.     
  64.     def _get_filter(self):
  65.         return self.filter
  66.  
  67.     
  68.     def _set_filter(self, filter):
  69.         self.filter = filter
  70.  
  71.     
  72.     def setFeature(self, name, state):
  73.         if self.supportsFeature(name):
  74.             if not state or 1:
  75.                 pass
  76.             state = 0
  77.             
  78.             try:
  79.                 settings = self._settings[(_name_xform(name), state)]
  80.             except KeyError:
  81.                 raise xml.dom.NotSupportedErr('unsupported feature: %r' % (name,))
  82.  
  83.             for name, value in settings:
  84.                 setattr(self._options, name, value)
  85.             
  86.         else:
  87.             raise xml.dom.NotFoundErr('unknown feature: ' + repr(name))
  88.  
  89.     
  90.     def supportsFeature(self, name):
  91.         return hasattr(self._options, _name_xform(name))
  92.  
  93.     
  94.     def canSetFeature(self, name, state):
  95.         if not state or 1:
  96.             pass
  97.         key = (_name_xform(name), 0)
  98.         return self._settings.has_key(key)
  99.  
  100.     _settings = {
  101.         ('namespace_declarations', 0): [
  102.             ('namespace_declarations', 0)],
  103.         ('namespace_declarations', 1): [
  104.             ('namespace_declarations', 1)],
  105.         ('validation', 0): [
  106.             ('validation', 0)],
  107.         ('external_general_entities', 0): [
  108.             ('external_general_entities', 0)],
  109.         ('external_general_entities', 1): [
  110.             ('external_general_entities', 1)],
  111.         ('external_parameter_entities', 0): [
  112.             ('external_parameter_entities', 0)],
  113.         ('external_parameter_entities', 1): [
  114.             ('external_parameter_entities', 1)],
  115.         ('validate_if_schema', 0): [
  116.             ('validate_if_schema', 0)],
  117.         ('create_entity_ref_nodes', 0): [
  118.             ('create_entity_ref_nodes', 0)],
  119.         ('create_entity_ref_nodes', 1): [
  120.             ('create_entity_ref_nodes', 1)],
  121.         ('entities', 0): [
  122.             ('create_entity_ref_nodes', 0),
  123.             ('entities', 0)],
  124.         ('entities', 1): [
  125.             ('entities', 1)],
  126.         ('whitespace_in_element_content', 0): [
  127.             ('whitespace_in_element_content', 0)],
  128.         ('whitespace_in_element_content', 1): [
  129.             ('whitespace_in_element_content', 1)],
  130.         ('cdata_sections', 0): [
  131.             ('cdata_sections', 0)],
  132.         ('cdata_sections', 1): [
  133.             ('cdata_sections', 1)],
  134.         ('comments', 0): [
  135.             ('comments', 0)],
  136.         ('comments', 1): [
  137.             ('comments', 1)],
  138.         ('charset_overrides_xml_encoding', 0): [
  139.             ('charset_overrides_xml_encoding', 0)],
  140.         ('charset_overrides_xml_encoding', 1): [
  141.             ('charset_overrides_xml_encoding', 1)],
  142.         ('infoset', 0): [],
  143.         ('infoset', 1): [
  144.             ('namespace_declarations', 0),
  145.             ('validate_if_schema', 0),
  146.             ('create_entity_ref_nodes', 0),
  147.             ('entities', 0),
  148.             ('cdata_sections', 0),
  149.             ('datatype_normalization', 1),
  150.             ('whitespace_in_element_content', 1),
  151.             ('comments', 1),
  152.             ('charset_overrides_xml_encoding', 1)],
  153.         ('supported_mediatypes_only', 0): [
  154.             ('supported_mediatypes_only', 0)],
  155.         ('namespaces', 0): [
  156.             ('namespaces', 0)],
  157.         ('namespaces', 1): [
  158.             ('namespaces', 1)] }
  159.     
  160.     def getFeature(self, name):
  161.         xname = _name_xform(name)
  162.         
  163.         try:
  164.             return getattr(self._options, xname)
  165.         except AttributeError:
  166.             if name == 'infoset':
  167.                 options = self._options
  168.                 if options.datatype_normalization and options.whitespace_in_element_content and options.comments and options.charset_overrides_xml_encoding:
  169.                     if not options.namespace_declarations and options.validate_if_schema and options.create_entity_ref_nodes and options.entities:
  170.                         pass
  171.                 return not (options.cdata_sections)
  172.             
  173.             raise xml.dom.NotFoundErr('feature %s not known' % repr(name))
  174.  
  175.  
  176.     
  177.     def parseURI(self, uri):
  178.         if self.entityResolver:
  179.             input = self.entityResolver.resolveEntity(None, uri)
  180.         else:
  181.             input = DOMEntityResolver().resolveEntity(None, uri)
  182.         return self.parse(input)
  183.  
  184.     
  185.     def parse(self, input):
  186.         options = copy.copy(self._options)
  187.         options.filter = self.filter
  188.         options.errorHandler = self.errorHandler
  189.         fp = input.byteStream
  190.         if fp is None and options.systemId:
  191.             import urllib2 as urllib2
  192.             fp = urllib2.urlopen(input.systemId)
  193.         
  194.         return self._parse_bytestream(fp, options)
  195.  
  196.     
  197.     def parseWithContext(self, input, cnode, action):
  198.         if action not in self._legal_actions:
  199.             raise ValueError('not a legal action')
  200.         
  201.         raise NotImplementedError("Haven't written this yet...")
  202.  
  203.     
  204.     def _parse_bytestream(self, stream, options):
  205.         import xml.dom.expatbuilder as xml
  206.         builder = xml.dom.expatbuilder.makeBuilder(options)
  207.         return builder.parseFile(stream)
  208.  
  209.  
  210.  
  211. def _name_xform(name):
  212.     return name.lower().replace('-', '_')
  213.  
  214.  
  215. class DOMEntityResolver(object):
  216.     __slots__ = ('_opener',)
  217.     
  218.     def resolveEntity(self, publicId, systemId):
  219.         source = DOMInputSource()
  220.         source.publicId = publicId
  221.         source.systemId = systemId
  222.         source.byteStream = self._get_opener().open(systemId)
  223.         source.encoding = self._guess_media_encoding(source)
  224.         import posixpath as posixpath
  225.         import urlparse as urlparse
  226.         parts = urlparse.urlparse(systemId)
  227.         (scheme, netloc, path, params, query, fragment) = parts
  228.         if path and not path.endswith('/'):
  229.             path = posixpath.dirname(path) + '/'
  230.             parts = (scheme, netloc, path, params, query, fragment)
  231.             source.baseURI = urlparse.urlunparse(parts)
  232.         
  233.         return source
  234.  
  235.     
  236.     def _get_opener(self):
  237.         
  238.         try:
  239.             return self._opener
  240.         except AttributeError:
  241.             self._opener = self._create_opener()
  242.             return self._opener
  243.  
  244.  
  245.     
  246.     def _create_opener(self):
  247.         import urllib2
  248.         return urllib2.build_opener()
  249.  
  250.     
  251.     def _guess_media_encoding(self, source):
  252.         info = source.byteStream.info()
  253.         if info.has_key('Content-Type'):
  254.             for param in info.getplist():
  255.                 if param.startswith('charset='):
  256.                     return param.split('=', 1)[1].lower()
  257.                     continue
  258.             
  259.         
  260.  
  261.  
  262.  
  263. class DOMInputSource(object):
  264.     __slots__ = ('byteStream', 'characterStream', 'stringData', 'encoding', 'publicId', 'systemId', 'baseURI')
  265.     
  266.     def __init__(self):
  267.         self.byteStream = None
  268.         self.characterStream = None
  269.         self.stringData = None
  270.         self.encoding = None
  271.         self.publicId = None
  272.         self.systemId = None
  273.         self.baseURI = None
  274.  
  275.     
  276.     def _get_byteStream(self):
  277.         return self.byteStream
  278.  
  279.     
  280.     def _set_byteStream(self, byteStream):
  281.         self.byteStream = byteStream
  282.  
  283.     
  284.     def _get_characterStream(self):
  285.         return self.characterStream
  286.  
  287.     
  288.     def _set_characterStream(self, characterStream):
  289.         self.characterStream = characterStream
  290.  
  291.     
  292.     def _get_stringData(self):
  293.         return self.stringData
  294.  
  295.     
  296.     def _set_stringData(self, data):
  297.         self.stringData = data
  298.  
  299.     
  300.     def _get_encoding(self):
  301.         return self.encoding
  302.  
  303.     
  304.     def _set_encoding(self, encoding):
  305.         self.encoding = encoding
  306.  
  307.     
  308.     def _get_publicId(self):
  309.         return self.publicId
  310.  
  311.     
  312.     def _set_publicId(self, publicId):
  313.         self.publicId = publicId
  314.  
  315.     
  316.     def _get_systemId(self):
  317.         return self.systemId
  318.  
  319.     
  320.     def _set_systemId(self, systemId):
  321.         self.systemId = systemId
  322.  
  323.     
  324.     def _get_baseURI(self):
  325.         return self.baseURI
  326.  
  327.     
  328.     def _set_baseURI(self, uri):
  329.         self.baseURI = uri
  330.  
  331.  
  332.  
  333. class DOMBuilderFilter:
  334.     FILTER_ACCEPT = 1
  335.     FILTER_REJECT = 2
  336.     FILTER_SKIP = 3
  337.     FILTER_INTERRUPT = 4
  338.     whatToShow = NodeFilter.SHOW_ALL
  339.     
  340.     def _get_whatToShow(self):
  341.         return self.whatToShow
  342.  
  343.     
  344.     def acceptNode(self, element):
  345.         return self.FILTER_ACCEPT
  346.  
  347.     
  348.     def startContainer(self, element):
  349.         return self.FILTER_ACCEPT
  350.  
  351.  
  352. del NodeFilter
  353.  
  354. class DocumentLS:
  355.     async = False
  356.     
  357.     def _get_async(self):
  358.         return False
  359.  
  360.     
  361.     def _set_async(self, async):
  362.         if async:
  363.             raise xml.dom.NotSupportedErr('asynchronous document loading is not supported')
  364.         
  365.  
  366.     
  367.     def abort(self):
  368.         raise NotImplementedError("haven't figured out what this means yet")
  369.  
  370.     
  371.     def load(self, uri):
  372.         raise NotImplementedError("haven't written this yet")
  373.  
  374.     
  375.     def loadXML(self, source):
  376.         raise NotImplementedError("haven't written this yet")
  377.  
  378.     
  379.     def saveXML(self, snode):
  380.         if snode is None:
  381.             snode = self
  382.         elif snode.ownerDocument is not self:
  383.             raise xml.dom.WrongDocumentErr()
  384.         
  385.         return snode.toxml()
  386.  
  387.  
  388.  
  389. class DOMImplementationLS:
  390.     MODE_SYNCHRONOUS = 1
  391.     MODE_ASYNCHRONOUS = 2
  392.     
  393.     def createDOMBuilder(self, mode, schemaType):
  394.         if schemaType is not None:
  395.             raise xml.dom.NotSupportedErr('schemaType not yet supported')
  396.         
  397.         if mode == self.MODE_SYNCHRONOUS:
  398.             return DOMBuilder()
  399.         
  400.         if mode == self.MODE_ASYNCHRONOUS:
  401.             raise xml.dom.NotSupportedErr('asynchronous builders are not supported')
  402.         
  403.         raise ValueError('unknown value for mode')
  404.  
  405.     
  406.     def createDOMWriter(self):
  407.         raise NotImplementedError("the writer interface hasn't been written yet!")
  408.  
  409.     
  410.     def createDOMInputSource(self):
  411.         return DOMInputSource()
  412.  
  413.  
  414.